const express = require('express')
const router = express.Router()
const jwt = require('jsonwebtoken')
const bcrypt = require('bcrypt')
const User = require('../models/User')

// JWT密钥和过期时间配置
const JWT_SECRET = process.env.JWT_SECRET || 'your_jwt_secret_key'
const JWT_EXPIRES_IN = process.env.JWT_EXPIRES_IN || '7d'

/**
 * 用户登录
 * @route POST /auth/login
 * @param {string} email - 用户邮箱
 * @param {string} password - 用户密码
 * @returns {object} 包含token和用户信息的响应
 */
router.post('/login', async (req, res) => {
  try {
    const { email, password } = req.body

    // 验证请求数据
    if (!email || !password) {
      return res.status(400).json({ 
        success: false,
        message: '邮箱和密码不能为空' 
      })
    }

    // 查找用户
    const user = await User.findOne({ email })
    if (!user) {
      return res.status(401).json({ 
        success: false,
        message: '邮箱或密码不正确' 
      })
    }

    // 检查账户状态
    if (!user.isActive) {
      return res.status(403).json({ 
        success: false,
        message: '账户已被禁用，请联系管理员' 
      })
    }

    // 验证密码
    const isMatch = await user.comparePassword(password)
    if (!isMatch) {
      return res.status(401).json({ 
        success: false,
        message: '邮箱或密码不正确' 
      })
    }

    // 生成JWT令牌
    const token = jwt.sign(
      { id: user._id, email: user.email, role: user.role },
      JWT_SECRET,
      { expiresIn: JWT_EXPIRES_IN }
    )

    // 更新最后活跃时间
    user.lastActive = Date.now()
    await user.save()

    // 返回令牌和用户信息
    res.json({
      success: true,
      token,
      user: {
        id: user._id,
        email: user.email,
        nickname: user.nickname,
        avatar: user.avatar,
        role: user.role
      }
    })
  } catch (error) {
    console.error('登录错误:', error)
    res.status(500).json({ 
      success: false,
      message: '服务器错误' 
    })
  }
})

/**
 * 用户登出
 * @route POST /auth/logout
 * @returns {object} 成功消息
 */
router.post('/logout', (req, res) => {
  // 客户端应该清除令牌，服务器端不需要特殊处理
  res.json({ 
    success: true,
    message: '成功登出' 
  })
})

/**
 * 获取当前用户信息
 * @route GET /auth/user
 * @returns {object} 用户信息
 */
router.get('/user', async (req, res) => {
  try {
    // 从请求头获取令牌
    const authHeader = req.headers['authorization']
    const token = authHeader && authHeader.split(' ')[1]
    
    if (!token) {
      return res.status(401).json({ 
        success: false,
        message: '未提供认证令牌' 
      })
    }
    
    // 验证令牌
    jwt.verify(token, JWT_SECRET, async (err, decoded) => {
      if (err) {
        return res.status(403).json({ 
          success: false,
          message: '令牌无效或已过期' 
        })
      }
      
      // 查找用户
      const user = await User.findById(decoded.id).select('-password')
      if (!user) {
        return res.status(404).json({ 
          success: false,
          message: '用户不存在' 
        })
      }
      
      // 返回用户信息
      res.json({
        success: true,
        user: {
          id: user._id,
          email: user.email,
          nickname: user.nickname,
          avatar: user.avatar,
          role: user.role,
          lastActive: user.lastActive
        }
      })
    })
  } catch (error) {
    console.error('获取用户信息错误:', error)
    res.status(500).json({ 
      success: false,
      message: '服务器错误' 
    })
  }
})

/**
 * 验证令牌有效性
 * @route GET /auth/verify
 * @returns {object} 验证结果
 */
router.get('/verify', (req, res) => {
  try {
    // 从请求头获取令牌
    const authHeader = req.headers['authorization']
    const token = authHeader && authHeader.split(' ')[1]
    
    if (!token) {
      return res.status(401).json({ 
        success: false,
        message: '未提供认证令牌' 
      })
    }
    
    // 验证令牌
    jwt.verify(token, JWT_SECRET, (err, decoded) => {
      if (err) {
        return res.status(403).json({ 
          success: false,
          message: '令牌无效或已过期' 
        })
      }
      
      // 令牌有效
      res.json({
        success: true,
        message: '令牌有效',
        user: {
          id: decoded.id,
          email: decoded.email,
          role: decoded.role
        }
      })
    })
  } catch (error) {
    console.error('验证令牌错误:', error)
    res.status(500).json({ 
      success: false,
      message: '服务器错误' 
    })
  }
})

/**
 * 谷歌OAuth登录回调
 * @route GET /auth/google/callback
 */
router.get('/google/callback', async (req, res) => {
  // 这里应该实现谷歌OAuth的回调处理
  // 由于需要谷歌开发者账号和配置，这里只提供基本框架
  res.status(501).json({ 
    success: false,
    message: '谷歌登录功能尚未实现' 
  })
})

/**
 * 重置密码请求
 * @route POST /auth/reset-password
 * @param {string} email - 用户邮箱
 */
router.post('/reset-password', async (req, res) => {
  try {
    const { email } = req.body
    
    if (!email) {
      return res.status(400).json({ 
        success: false,
        message: '邮箱不能为空' 
      })
    }
    
    // 查找用户
    const user = await User.findOne({ email })
    if (!user) {
      // 出于安全考虑，即使用户不存在也返回成功
      return res.json({ 
        success: true,
        message: '如果该邮箱已注册，重置密码的邮件将发送到该地址' 
      })
    }
    
    // 这里应该生成重置令牌并发送邮件
    // 由于需要邮件服务配置，这里只提供基本框架
    
    res.json({ 
      success: true,
      message: '如果该邮箱已注册，重置密码的邮件将发送到该地址' 
    })
  } catch (error) {
    console.error('重置密码请求错误:', error)
    res.status(500).json({ 
      success: false,
      message: '服务器错误' 
    })
  }
})

module.exports = router